import { ElMessage, ElNotification } from 'element-plus'

/**
 * 错误类型枚举
 */
export const ErrorType = {
  BUSINESS: 'BUSINESS',           // 业务异常
  SYSTEM: 'SYSTEM',              // 系统异常
  AUTHENTICATION: 'AUTHENTICATION', // 认证异常
  AUTHORIZATION: 'AUTHORIZATION',   // 授权异常
  VALIDATION: 'VALIDATION',        // 参数验证异常
  NETWORK: 'NETWORK',             // 网络异常
  UNKNOWN: 'UNKNOWN'              // 未知异常
}

/**
 * 错误级别枚举
 */
export const ErrorLevel = {
  INFO: 'INFO',
  WARN: 'WARN',
  ERROR: 'ERROR',
  FATAL: 'FATAL'
}

/**
 * 错误码映射表
 */
export const ErrorCodeMap = {
  // 通用错误
  '10000': '系统内部错误',
  '10001': '参数错误',
  '10002': '网络连接失败',
  '10003': '请求超时',
  '10004': '未知错误',

  // 用户相关错误
  '20001': '用户不存在',
  '20002': '用户已存在',
  '20003': '密码错误',
  '20004': '用户已被禁用',
  '20005': '用户已被锁定',
  '20006': '用户未激活',

  // 认证相关错误
  '30001': 'Token无效',
  '30002': 'Token已过期',
  '30003': 'Token缺失',
  '30004': '登录失败',
  '30007': '验证码错误',
  '30008': '验证码错误',

  // 权限相关错误
  '40001': '权限不足',
  '40002': '权限不存在',
  '40005': '角色不存在',
  '40009': '菜单访问被拒绝',

  // 数据相关错误
  '50001': '数据不存在',
  '50002': '数据已存在',
  '50003': '数据验证失败',
  '50004': '数据保存失败',
  '50005': '数据更新失败',
  '50006': '数据删除失败',
  '50008': '数据约束违反',
  '50009': '数据完整性错误',

  // 外键约束相关错误
  '50101': '外键约束违反',
  '50102': '删除被限制',
  '50103': '更新被限制',
  '50104': '引用数据不存在',
  '50105': '存在循环引用',
  '50106': '存在依赖关系',

  // 具体业务外键约束错误
  '50201': '用户存在角色关联',
  '50202': '用户存在余额记录',
  '50203': '用户存在充值记录',
  '50204': '用户存在操作日志',
  '50205': '角色被用户使用',
  '50206': '角色绑定了菜单',
  '50207': '角色绑定了权限',
  '50208': '菜单包含子菜单',
  '50209': '菜单被角色绑定',
  '50210': '权限包含子权限',
  '50211': '权限被角色绑定'
}

/**
 * 用户友好的错误提示映射
 */
export const UserFriendlyMessages = {
  // 认证相关
  '30001': '登录已过期，请重新登录',
  '30002': '登录已过期，请重新登录',
  '30003': '请先登录',
  '30004': '用户名或密码错误',
  '30007': '验证码错误，请重新输入',
  '30008': '验证码错误，请重新输入',

  // 权限相关
  '40001': '您没有权限执行此操作',
  '40009': '您没有权限访问此页面',

  // 数据相关
  '50001': '请求的数据不存在',
  '50002': '数据已存在，请勿重复操作',
  '50003': '输入的数据格式不正确',
  '50004': '保存失败，请重试',
  '50005': '更新失败，请重试',
  '50006': '删除失败，请重试',
  '50008': '数据操作违反了约束条件',
  '50009': '数据完整性检查失败',

  // 外键约束相关
  '50101': '操作违反了数据关联约束',
  '50102': '存在关联数据，无法删除',
  '50103': '存在关联数据，无法更新',
  '50104': '引用的数据不存在',
  '50105': '存在循环引用关系',
  '50106': '存在数据依赖关系',

  // 具体业务外键约束错误
  '50201': '用户正在被角色使用，无法删除',
  '50202': '用户存在余额记录，无法删除',
  '50203': '用户存在充值记录，无法删除',
  '50204': '用户存在操作日志，无法删除',
  '50205': '角色正在被用户使用，无法删除',
  '50206': '角色绑定了菜单权限，无法删除',
  '50207': '角色绑定了操作权限，无法删除',
  '50208': '菜单包含子菜单，无法删除',
  '50209': '菜单被角色绑定，无法删除',
  '50210': '权限包含子权限，无法删除',
  '50211': '权限被角色绑定，无法删除'
}

/**
 * 处理API响应，检查后端返回的结果并显示相应的消息
 * @param {Object} response - API响应对象
 * @param {string} successMessage - 成功时显示的消息
 * @param {string} defaultErrorMessage - 默认错误消息
 * @returns {boolean} - 是否成功
 */
export function handleApiResponse(response, successMessage = '操作成功', defaultErrorMessage = '操作失败') {
  if (response.data.code === 200) {
    if (successMessage) {
      ElMessage.success(successMessage)
    }
    return true
  } else {
    ElMessage.error(response.data.message || defaultErrorMessage)
    return false
  }
}

/**
 * 解析错误响应
 */
export function parseErrorResponse(error) {
  // 默认错误信息
  const defaultError = {
    errorCode: '10000',
    errorMessage: '系统错误',
    errorCategory: ErrorType.SYSTEM,
    errorLevel: ErrorLevel.ERROR,
    userMessage: '系统暂时不可用，请稍后重试',
    suggestion: '请刷新页面重试，如问题持续存在请联系管理员'
  }

  // 网络错误
  if (!error.response) {
    return {
      ...defaultError,
      errorCode: '10002',
      errorMessage: '网络连接失败',
      errorCategory: ErrorType.NETWORK,
      userMessage: '网络连接失败，请检查网络设置',
      suggestion: '请检查网络连接后重试'
    }
  }

  // HTTP状态码错误
  const status = error.response.status
  if (status === 401) {
    return {
      ...defaultError,
      errorCode: '30001',
      errorMessage: '未授权访问',
      errorCategory: ErrorType.AUTHENTICATION,
      userMessage: '登录已过期，请重新登录',
      suggestion: '请重新登录后再试'
    }
  }

  if (status === 403) {
    return {
      ...defaultError,
      errorCode: '40001',
      errorMessage: '权限不足',
      errorCategory: ErrorType.AUTHORIZATION,
      userMessage: '您没有权限执行此操作',
      suggestion: '请联系管理员获取相应权限'
    }
  }

  if (status === 404) {
    return {
      ...defaultError,
      errorCode: '40404',
      errorMessage: '资源不存在',
      errorCategory: ErrorType.BUSINESS,
      userMessage: '请求的资源不存在',
      suggestion: '请检查请求地址是否正确'
    }
  }

  if (status >= 500) {
    return {
      ...defaultError,
      errorCode: '10000',
      errorMessage: '服务器内部错误',
      errorCategory: ErrorType.SYSTEM,
      userMessage: '服务器暂时不可用，请稍后重试',
      suggestion: '请稍后重试，如问题持续存在请联系管理员'
    }
  }

  // 解析响应数据中的错误信息
  const responseData = error.response.data
  if (responseData && responseData.data && typeof responseData.data === 'object') {
    const errorData = responseData.data
    return {
      errorCode: errorData.errorCode || defaultError.errorCode,
      errorMessage: errorData.errorMessage || responseData.message || defaultError.errorMessage,
      errorCategory: errorData.errorCategory || defaultError.errorCategory,
      errorLevel: errorData.errorLevel || defaultError.errorLevel,
      userMessage: errorData.userMessage || getUserFriendlyMessage(errorData.errorCode) || defaultError.userMessage,
      suggestion: errorData.suggestion || defaultError.suggestion,
      errorDetails: errorData.errorDetails,
      requestId: errorData.requestId,
      path: errorData.path,
      method: errorData.method,
      timestamp: errorData.timestamp
    }
  }

  // 简单错误响应
  if (responseData && responseData.message) {
    return {
      ...defaultError,
      errorMessage: responseData.message,
      userMessage: responseData.message
    }
  }

  return defaultError
}

/**
 * 获取用户友好的错误提示
 */
export function getUserFriendlyMessage(errorCode) {
  return UserFriendlyMessages[errorCode] || ErrorCodeMap[errorCode]
}

/**
 * 显示错误消息
 */
export function showErrorMessage(error, options = {}) {
  const errorInfo = parseErrorResponse(error)

  const {
    showNotification = false,
    showMessage = true,
    duration = 3000,
    showDetails = false
  } = options

  // 显示用户友好的消息
  const displayMessage = errorInfo.userMessage || errorInfo.errorMessage

  if (showMessage) {
    ElMessage({
      type: 'error',
      message: displayMessage,
      duration: duration,
      showClose: true
    })
  }

  if (showNotification) {
    ElNotification({
      type: 'error',
      title: '操作失败',
      message: displayMessage,
      duration: duration,
      showClose: true
    })
  }

  // 开发环境显示详细错误信息
  if (showDetails && import.meta.env.DEV) {
    console.group('🚨 错误详情')
    console.error('错误码:', errorInfo.errorCode)
    console.error('错误消息:', errorInfo.errorMessage)
    console.error('错误分类:', errorInfo.errorCategory)
    console.error('错误级别:', errorInfo.errorLevel)
    console.error('用户提示:', errorInfo.userMessage)
    console.error('建议方案:', errorInfo.suggestion)
    if (errorInfo.errorDetails) {
      console.error('错误详情:', errorInfo.errorDetails)
    }
    if (errorInfo.requestId) {
      console.error('请求ID:', errorInfo.requestId)
    }
    console.error('原始错误:', error)
    console.groupEnd()
  }

  return errorInfo
}

/**
 * 处理API错误，显示友好的错误信息
 * @param {Error} error - 错误对象
 * @param {string} defaultMessage - 默认错误消息
 */
export function handleApiError(error, options = {}) {
  // 如果是用户取消操作，不显示错误
  if (error === 'cancel' || error.message === 'User canceled the dialog') {
    return
  }

  const errorInfo = showErrorMessage(error, {
    showDetails: true,
    ...options
  })

  // 特殊错误处理
  if (errorInfo.errorCategory === ErrorType.AUTHENTICATION) {
    // 认证失败，跳转到登录页
    setTimeout(() => {
      window.location.href = '/login'
    }, 1000)
  }

  return errorInfo
}

/**
 * 显示成功消息的工具函数
 * @param {string} message - 成功消息
 */
export function showSuccess(message) {
  ElMessage.success(message)
}

/**
 * 显示错误消息的工具函数
 * @param {string} message - 错误消息
 */
export function showError(message) {
  ElMessage.error(message)
}

/**
 * 显示警告消息的工具函数
 * @param {string} message - 警告消息
 */
export function showWarning(message) {
  ElMessage.warning(message)
}

/**
 * 显示信息消息的工具函数
 * @param {string} message - 信息消息
 */
export function showInfo(message) {
  ElMessage.info(message)
}

/**
 * 创建错误对象
 */
export function createError(errorCode, errorMessage, errorCategory = ErrorType.BUSINESS) {
  return {
    errorCode,
    errorMessage,
    errorCategory,
    userMessage: getUserFriendlyMessage(errorCode) || errorMessage
  }
}

/**
 * 验证错误处理
 */
export function handleValidationError(errors) {
  if (Array.isArray(errors)) {
    // 多个验证错误
    const messages = errors.map(error => error.message || error).join('; ')
    ElMessage({
      type: 'warning',
      message: `输入验证失败: ${messages}`,
      duration: 4000,
      showClose: true
    })
  } else if (typeof errors === 'object') {
    // 字段验证错误
    const fieldErrors = Object.entries(errors)
      .map(([field, message]) => `${field}: ${message}`)
      .join('; ')
    ElMessage({
      type: 'warning',
      message: `输入验证失败: ${fieldErrors}`,
      duration: 4000,
      showClose: true
    })
  } else {
    // 单个验证错误
    ElMessage({
      type: 'warning',
      message: errors || '输入验证失败',
      duration: 3000,
      showClose: true
    })
  }
}

/**
 * 业务错误处理
 */
export function handleBusinessError(errorCode, errorMessage, options = {}) {
  const userMessage = getUserFriendlyMessage(errorCode) || errorMessage

  ElMessage({
    type: 'warning',
    message: userMessage,
    duration: options.duration || 3000,
    showClose: true
  })

  return createError(errorCode, errorMessage, ErrorType.BUSINESS)
}

/**
 * 系统错误处理
 */
export function handleSystemError(errorMessage, options = {}) {
  ElMessage({
    type: 'error',
    message: '系统暂时不可用，请稍后重试',
    duration: options.duration || 3000,
    showClose: true
  })

  // 开发环境显示详细错误
  if (import.meta.env.DEV) {
    console.error('系统错误:', errorMessage)
  }

  return createError('10000', errorMessage, ErrorType.SYSTEM)
}

/**
 * 外键约束错误处理
 */
export function handleForeignKeyError(errorData, options = {}) {
  const {
    showNotification = true,
    showMessage = false,
    duration = 5000
  } = options

  const userMessage = errorData.userMessage || errorData.errorMessage || '操作失败'
  const suggestion = errorData.suggestion || '请先处理相关依赖数据'

  if (showMessage) {
    ElMessage({
      type: 'warning',
      message: userMessage,
      duration: duration,
      showClose: true
    })
  }

  if (showNotification) {
    ElNotification({
      type: 'warning',
      title: '操作受限',
      message: `${userMessage}\n\n解决方案：${suggestion}`,
      duration: duration,
      showClose: true,
      dangerouslyUseHTMLString: false
    })
  }

  return errorData
}

/**
 * 显示外键约束确认对话框
 */
export async function showForeignKeyConfirmDialog(operation, dependencies, options = {}) {
  const { ElMessageBox } = await import('element-plus')
  
  const {
    title = '操作确认',
    confirmButtonText = '继续操作',
    cancelButtonText = '取消',
    type = 'warning'
  } = options

  let content = `您正在执行${operation}操作，但检测到以下依赖关系：\n\n`
  
  if (Array.isArray(dependencies)) {
    content += dependencies.map(dep => `• ${dep}`).join('\n')
  } else {
    content += dependencies
  }
  
  content += '\n\n请确认是否继续？继续操作可能会影响相关数据。'

  try {
    await ElMessageBox.confirm(content, title, {
      confirmButtonText,
      cancelButtonText,
      type,
      distinguishCancelAndClose: true,
      beforeClose: (action, instance, done) => {
        if (action === 'confirm') {
          instance.confirmButtonLoading = true
          instance.confirmButtonText = '处理中...'
          setTimeout(() => {
            done()
          }, 300)
        } else {
          done()
        }
      }
    })
    return true
  } catch (error) {
    return false
  }
}

/**
 * 显示删除前依赖检查警告
 */
export async function showDeleteWarning(itemName, dependencies, options = {}) {
  const { ElMessageBox } = await import('element-plus')
  
  const {
    title = '删除警告',
    type = 'warning'
  } = options

  let message = `您确定要删除"${itemName}"吗？\n\n`
  
  if (dependencies && dependencies.length > 0) {
    message += '⚠️ 注意：删除后将同时影响以下关联数据：\n\n'
    message += dependencies.map(dep => `• ${dep}`).join('\n')
    message += '\n\n此操作不可恢复，请谨慎操作！'
  } else {
    message += '此操作不可恢复，请确认是否继续？'
  }

  try {
    await ElMessageBox.confirm(message, title, {
      confirmButtonText: '确定删除',
      cancelButtonText: '取消',
      type,
      distinguishCancelAndClose: true,
      beforeClose: (action, instance, done) => {
        if (action === 'confirm') {
          instance.confirmButtonLoading = true
          instance.confirmButtonText = '删除中...'
          setTimeout(() => {
            done()
          }, 300)
        } else {
          done()
        }
      }
    })
    return true
  } catch (error) {
    return false
  }
}

/**
 * 批量操作前的依赖检查警告
 */
export async function showBatchOperationWarning(operation, items, dependencies = [], options = {}) {
  const { ElMessageBox } = await import('element-plus')
  
  const {
    title = '批量操作确认',
    type = 'warning'
  } = options

  let message = `您确定要${operation}选中的 ${items.length} 项吗？\n\n`
  
  if (dependencies.length > 0) {
    message += '⚠️ 检测到以下依赖关系可能受到影响：\n\n'
    message += dependencies.slice(0, 5).map(dep => `• ${dep}`).join('\n')
    if (dependencies.length > 5) {
      message += `\n• 以及其他 ${dependencies.length - 5} 项依赖...`
    }
    message += '\n\n请确认是否继续？'
  }

  try {
    await ElMessageBox.confirm(message, title, {
      confirmButtonText: `确定${operation}`,
      cancelButtonText: '取消',
      type,
      distinguishCancelAndClose: true
    })
    return true
  } catch (error) {
    return false
  }
}

export default {
  ErrorType,
  ErrorLevel,
  ErrorCodeMap,
  UserFriendlyMessages,
  parseErrorResponse,
  showErrorMessage,
  handleApiError,
  handleValidationError,
  handleBusinessError,
  handleSystemError,
  createError,
  getUserFriendlyMessage,
  handleApiResponse,
  showSuccess,
  showError,
  showWarning,
  showInfo
}